package net.sourceforge.lame.mp3;

import net.sourceforge.lame.mpg.MPGLib;

public class LameInternalFlags {

  public static final int MFSIZE = (3 * 1152 + Encoder.ENCDELAY - Encoder.MDCTDELAY);
  public float mfbuf[][] = new float[2][MFSIZE];
  public static final int MAX_BITS_PER_CHANNEL = 4095;
  public static final int MAX_BITS_PER_GRANULE = 7680;

  /********************************************************************
   * internal variables NOT set by calling program, and should not be *
   * modified by the calling program *
   ********************************************************************/
  /* BPC = maximum number of filter convolution windows to precompute */
  public static final int BPC = 320;
  public float[][] blackfilt = new float[2 * BPC + 1][];
  /**
   * also, max_header_buf has to be a power of two
   */
  public static final int MAX_HEADER_BUF = 256;
  public Header[] header = new Header[MAX_HEADER_BUF];
  /**
   * max size of header is 38
   */
  private static final int MAX_HEADER_LEN = 40;
  /**
   * Some remarks to the Class_ID field: The Class ID is an Identifier for a
   * pointer to this struct. It is very unlikely that a pointer to
   * lame_global_flags has the same 32 bits in it's structure (large and other
   * special properties, for instance prime).
   * <p/>
   * To test that the structure is right and initialized, use: if ( gfc .
   * Class_ID == LAME_ID ) ... Other remark: If you set a flag to 0 for uninit
   * data and 1 for init data, the right test should be "if (flag == 1)" and
   * NOT "if (flag)". Unintended modification of this element will be
   * otherwise misinterpreted as an init.
   */
  public long Class_ID;
  public int lame_encode_frame_init;
  public int iteration_init_init;
  public int fill_buffer_resample_init;
  /**
   * granules per frame
   */
  public int mode_gr;
  /**
   * number of channels in the input data stream (PCM or decoded PCM)
   */
  public int channels_in;
  /**
   * number of channels in the output data stream (not used for decoding)
   */
  public int channels_out;
  /**
   * input_samp_rate/output_samp_rate
   */
  public double resample_ratio;
  public int mf_samples_to_encode;
  public int mf_size;
  /**
   * min bitrate index
   */
  public int VBR_min_bitrate;

	/* lowpass and highpass filter control */
  /**
   * max bitrate index
   */
  public int VBR_max_bitrate;
  public int bitrate_index;
  public int samplerate_index;
  public int mode_ext;
  /**
   * normalized frequency bounds of passband
   */
  public float lowpass1, lowpass2;
  /**
   * normalized frequency bounds of passband
   */
  public float highpass1, highpass2;
  /**
   * 0 = none 1 = ISO AAC model 2 = allow scalefac_select=1
   */
  public int noise_shaping;
  /**
   * 0 = ISO model: amplify all distorted bands<BR>
   * 1 = amplify within 50% of max (on db scale)<BR>
   * 2 = amplify only most distorted band<BR>
   * 3 = method 1 and refine with method 2<BR>
   */
  public int noise_shaping_amp;
  /**
   * 0 = no substep<BR>
   * 1 = use substep shaping at last step(VBR only)<BR>
   * (not implemented yet)<BR>
   * 2 = use substep inside loop<BR>
   * 3 = use substep inside loop and last step<BR>
   */
  public int substep_shaping;
  /**
   * 1 = gpsycho. 0 = none
   */
  public int psymodel;
  /**
   * 0 = stop at over=0, all scalefacs amplified or<BR>
   * a scalefac has reached max value<BR>
   * 1 = stop when all scalefacs amplified or a scalefac has reached max value<BR>
   * 2 = stop when all scalefacs amplified
   */
  public int noise_shaping_stop;
  /**
   * 0 = no, 1 = yes
   */
  public int subblock_gain;

	/* used for padding */
  /**
   * 0 = no. 1=outside loop 2=inside loop(slow)
   */
  public int use_best_huffman;
  /**
   * 0 = stop early after 0 distortion found. 1 = full search
   */
  public int full_outer_loop;
  public IIISideInfo l3_side = new IIISideInfo();
  public float ms_ratio[] = new float[2];
  /**
   * padding for the current frame?
   */
  public int padding;
  public int frac_SpF;
  public int slot_lag;
  /**
   * optional ID3 tags
   */
  public ID3TagSpec tag_spec;
  public int nMusicCRC;
  /* variables used by Quantize */
  public int OldValue[] = new int[2];
  public int CurrentStep[] = new int[2];
  public float masking_lower;
  public int bv_scf[] = new int[576];
  public int pseudohalf[] = new int[L3Side.SFBMAX];
  /**
   * will be set in Lame.initParams
   */
  public boolean sfb21_extra;
  public float[][] inbuf_old = new float[2][];
  public double itime[] = new double[2];
  public int sideinfo_len;

	/* variables for BitStream */

  /**
   * <PRE>
   * mpeg1: buffer=511 bytes  smallest frame: 96-38(sideinfo)=58
   * max number of frames in reservoir:  8
   * mpeg2: buffer=255 bytes.  smallest frame: 24-23bytes=1
   * with VBR, if you are encoding all silence, it is possible to
   * have 8kbs/24khz frames with 1byte of data each, which means we need
   * to buffer up to 255 headers!
   * </PRE>
   */
  /* variables for newmdct.c */
  public float sb_sample[][][][] = new float[2][2][18][Encoder.SBLIMIT];
  public float amp_filter[] = new float[32];
  public int h_ptr;
  public int w_ptr;
  public int ancillary_flag;
  /**
   * in bits
   */
  public int ResvSize;
  /**
   * in bits
   */
  public int ResvMax;

	/* variables for Reservoir */
  public ScaleFac scalefac_band = new ScaleFac();
  /* daa from PsyModel */
  /* The static variables "r", "phi_sav", "new", "old" and "oldest" have */
	/* to be remembered for the unpredictability measure. For "r" and */
	/* "phi_sav", the first index from the left is the channel select and */
	/* the second index is the "age" of the data. */
  public float minval_l[] = new float[Encoder.CBANDS];
  public float minval_s[] = new float[Encoder.CBANDS];
  public float nb_1[][] = new float[4][Encoder.CBANDS],
      nb_2[][] = new float[4][Encoder.CBANDS];
  public float nb_s1[][] = new float[4][Encoder.CBANDS],
      nb_s2[][] = new float[4][Encoder.CBANDS];
  public float[] s3_ss;
  public float[] s3_ll;
  public float decay;
  public III_psy_xmin[] thm = new III_psy_xmin[4];
  public III_psy_xmin[] en = new III_psy_xmin[4];
  /**
   * fft and energy calculation
   */
  public float tot_ener[] = new float[4];
  /**
   * loudness^2 approx. per granule and channel
   */
  public float loudness_sq[][] = new float[2][2];
  /**
   * account for granule delay of L3psycho_anal
   */
  public float loudness_sq_save[] = new float[2];

	/* loudness calculation (for adaptive threshold of hearing) */
  /**
   * Scale Factor Bands
   */
  public float mld_l[] = new float[Encoder.SBMAX_l],
      mld_s[] = new float[Encoder.SBMAX_s];
  public int bm_l[] = new int[Encoder.SBMAX_l],
      bo_l[] = new int[Encoder.SBMAX_l];
  public int bm_s[] = new int[Encoder.SBMAX_s],
      bo_s[] = new int[Encoder.SBMAX_s];
  public int npart_l, npart_s;
  public int s3ind[][] = new int[Encoder.CBANDS][2];
  public int s3ind_s[][] = new int[Encoder.CBANDS][2];
  public int numlines_s[] = new int[Encoder.CBANDS];
  public int numlines_l[] = new int[Encoder.CBANDS];
  public float rnumlines_l[] = new float[Encoder.CBANDS];
  public float mld_cb_l[] = new float[Encoder.CBANDS],
      mld_cb_s[] = new float[Encoder.CBANDS];
  public int numlines_s_num1;
  public int numlines_l_num1;
  /* ratios */
  public float pe[] = new float[4];
  public float ms_ratio_s_old, ms_ratio_l_old;
  public float ms_ener_ratio_old;
  /**
   * block type
   */
  public int blocktype_old[] = new int[2];
  /**
   * variables used for --nspsytune
   */
  public NsPsy nsPsy = new NsPsy();
  /**
   * used for Xing VBR header
   */
  public VBRSeekInfo VBR_seek_table = new VBRSeekInfo();
  /**
   * all ATH related stuff
   */
  public ATH ATH;
  public PSY PSY;
  public int nogap_total;
  public int nogap_current;
  /* ReplayGain */
  public boolean decode_on_the_fly = true;
  public boolean findReplayGain = true;
  public boolean findPeakSample = true;
  public float PeakSample;
  public int RadioGain;
  public int AudiophileGain;
  public ReplayGain rgdata;
  /**
   * gain change required for preventing clipping
   */
  public int noclipGainChange;
  /**
   * user-specified scale factor required for preventing clipping
   */
  public float noclipScale;
  /* simple statistics */
  public int bitrate_stereoMode_Hist[][] = new int[16][4 + 1];
  /**
   * norm/start/short/stop/mixed(short)/sum
   */
  public int bitrate_blockType_Hist[][] = new int[16][4 + 1 + 1];
  public PlottingData pinfo;
  public MPGLib.mpstr_tag hip;
  public int in_buffer_nsamples;
  public float[] in_buffer_0;
  public float[] in_buffer_1;
  public IIterationLoop iteration_loop;
  public LameInternalFlags() {
    for (int i = 0; i < en.length; i++) {
      en[i] = new III_psy_xmin();
    }
    for (int i = 0; i < thm.length; i++) {
      thm[i] = new III_psy_xmin();
    }
    for (int i = 0; i < header.length; i++) {
      header[i] = new Header();
    }
  }

  public static class Header {
    public int write_timing;
    public int ptr;
    public byte buf[] = new byte[MAX_HEADER_LEN];
  }

}
